// import html2Canvas from 'html2canvas'
// import { jsPDF } from 'jspdf'

// pdfDom 页面dom, intervalHeight 留白间距, fileName 文件名
export function html2Pdf(pdfDom, intervalHeight, fileName) {
  console.log("开始生成PDF...");
  
  // PDF尺寸配置 - A4尺寸（单位：点）
  const A4_WIDTH = 592.28;
  const A4_HEIGHT = 841.89;
  const PAGE_MARGIN_TOP = 30;    // 减少顶部留白
  const PAGE_MARGIN_BOTTOM = 30; // 减少底部留白
  const PAGE_MARGIN_LEFT = 30;   // 左侧留白
  const PAGE_MARGIN_RIGHT = 30;  // 右侧留白
  
  // 内容区域的有效宽高
  const CONTENT_WIDTH = A4_WIDTH - PAGE_MARGIN_LEFT - PAGE_MARGIN_RIGHT;
  const CONTENT_HEIGHT = A4_HEIGHT - PAGE_MARGIN_TOP - PAGE_MARGIN_BOTTOM;
  
  // 创建全局的jsPDF实例
  let pdf = null;
  
  // 确保所有图片都已加载完成
  const loadAllImages = () => {
    const images = pdfDom.querySelectorAll('img');
    console.log(`发现 ${images.length} 张图片，等待加载完成...`);
    
    const imagePromises = Array.from(images).map(img => {
      if (img.complete) return Promise.resolve();
      return new Promise(resolve => {
        img.onload = resolve;
        img.onerror = resolve;
      });
    });
    
    return Promise.all(imagePromises);
  };
  
  // 创建一个包含独立内容的块 - 每个块将单独渲染并添加到PDF中
  const createContentBlock = (element, index) => {
    // 创建一个包含元素的临时容器
    const container = document.createElement('div');
    container.style.width = `${CONTENT_WIDTH}px`;
    container.style.position = 'absolute';
    container.style.left = '-9999px';
    container.style.backgroundColor = '#FFFFFF';
    container.style.overflow = 'visible';
    container.style.padding = '0';
    container.style.margin = '0';
    
    // 克隆原始元素到容器中
    const clone = element.cloneNode(true);
    
    // 减少元素间距
    if (clone.style) {
      // 减少段落的margin和padding
      if (clone.tagName === 'P') {
        clone.style.margin = '0 0 8px 0'; // 减少段落间距
        clone.style.padding = '0';
      }
      
      // 压缩图片容器的间距
      if (clone.classList && clone.classList.contains('image-container')) {
        clone.style.margin = '8px 0'; // 减少图片容器上下间距
      }
    }
    
    // 为所有图片添加样式，确保不超出容器
    const images = clone.querySelectorAll('img');
    images.forEach(img => {
      img.style.maxWidth = '100%';
      img.style.height = 'auto';
      img.style.pageBreakInside = 'avoid';
      img.style.margin = '0'; // 移除图片margin
      
      // 修复可能的图片源问题
      if (img.src && img.src.startsWith('data:')) {
        // 数据URL不处理
      } else if (img.src) {
        // 尝试解决跨域问题
        img.crossOrigin = 'anonymous';
      }
    });
    
    container.appendChild(clone);
    document.body.appendChild(container);
    
    // 标记此块
    container.setAttribute('data-pdf-block', `block-${index}`);
    
    return container;
  };
  
  // 预处理文本块，将段落分解为可控大小的块
  const preprocessContentBlocks = (element) => {
    // 直接返回不应被拆分的元素
    if (element.tagName === 'IMG' || 
        element.querySelector('img') || 
        ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'].includes(element.tagName)) {
      return [element];
    }
    
    // 检查是否是大段文本
    if (element.tagName === 'P' && element.textContent.length > 300) {
      // 获取文本内容
      const text = element.textContent;
      // 分割成句子
      const sentences = text.match(/[^。！？.!?]+[。！？.!?]*/g) || [text];
      
      // 如果句子少于3个，不拆分
      if (sentences.length < 3) return [element];
      
      // 将句子分组，每组约200字
      const chunks = [];
      let currentChunk = '';
      let chunkSize = 0;
      
      sentences.forEach(sentence => {
        // 如果当前块加上这个句子不超过200字，添加到当前块
        if (chunkSize + sentence.length <= 200) {
          currentChunk += sentence;
          chunkSize += sentence.length;
        } else {
          // 否则创建新块
          if (currentChunk) {
            chunks.push(currentChunk);
          }
          currentChunk = sentence;
          chunkSize = sentence.length;
        }
      });
      
      // 添加最后一个块
      if (currentChunk) {
        chunks.push(currentChunk);
      }
      
      // 创建DOM元素表示这些块
      const blocks = chunks.map(chunk => {
        const p = document.createElement('p');
        p.textContent = chunk;
        p.style.margin = '0 0 5px 0'; // 减少间距
        p.style.padding = '0';
        return p;
      });
      
      return blocks;
    }
    
    // 默认不拆分
    return [element];
  };
  
  // 将DOM元素分解为可单独渲染的小块
  const divideContentIntoBlocks = () => {
    try {
      // 获取所有内容元素
      const contentElements = Array.from(pdfDom.querySelectorAll('.rich_media_content > *'));
      console.log(`找到 ${contentElements.length} 个内容元素，开始分解...`);
      
      // 分解这些元素
      const blocks = [];
      contentElements.forEach(element => {
        const processedBlocks = preprocessContentBlocks(element);
        blocks.push(...processedBlocks);
      });
      
      console.log(`分解完成，共得到 ${blocks.length} 个内容块`);
      return blocks;
    } catch (error) {
      console.error('分解内容块失败:', error);
      // 失败时返回原始内容元素
      return Array.from(pdfDom.querySelectorAll('.rich_media_content > *'));
    }
  };
  
  // 渲染单个内容块
  const renderBlock = async (container) => {
    return new Promise((resolve, reject) => {
      try {
        html2canvas(container, {
          scale: 2,
          useCORS: true,
          allowTaint: true,
          backgroundColor: '#FFFFFF',
          logging: false,
          x: 0,
          y: 0,
          imageTimeout: 15000, // 增加图像加载超时时间
          onclone: (clonedDoc) => {
            // 修复可能的图片问题
            const images = clonedDoc.querySelectorAll('img');
            images.forEach(img => {
              // 确保图片有宽高
              if (img.naturalWidth === 0 || img.naturalHeight === 0) {
                img.style.visibility = 'hidden'; // 隐藏有问题的图片
              }
            });
          }
        }).then(canvas => {
          resolve(canvas);
        }).catch(error => {
          console.warn('渲染块尝试失败，使用备用方案:', error);
          
          // 创建一个备用的canvas作为容错方案
          const backupCanvas = document.createElement('canvas');
          const ctx = backupCanvas.getContext('2d');
          
          // 设置基本尺寸
          backupCanvas.width = 500;
          backupCanvas.height = 30;
          
          // 填充白色背景
          ctx.fillStyle = '#FFFFFF';
          ctx.fillRect(0, 0, backupCanvas.width, backupCanvas.height);
          
          // 添加错误文本
          ctx.fillStyle = '#FF0000';
          ctx.font = '14px Arial';
          ctx.fillText('内容渲染错误', 10, 20);
          
          resolve(backupCanvas);
        });
      } catch (error) {
        console.error('渲染块出现异常:', error);
        reject(error);
      }
    });
  };
  
  // 渲染标题块 - 用于第一页
  const renderTitleBlock = async () => {
    const titleElement = pdfDom.querySelector('.rich_media_title');
    const metaElement = pdfDom.querySelector('.rich_media_meta_list');
    
    if (!titleElement) {
      return null;
    }
    
    // 创建标题容器
    const container = document.createElement('div');
    container.style.width = `${CONTENT_WIDTH}px`;
    container.style.position = 'absolute';
    container.style.left = '-9999px';
    container.style.backgroundColor = '#FFFFFF';
    container.style.padding = '0';
    container.style.margin = '0';
    
    // 添加标题和元数据
    const titleClone = titleElement.cloneNode(true);
    // 减少标题的间距
    titleClone.style.margin = '0 0 5px 0';
    titleClone.style.padding = '0';
    container.appendChild(titleClone);
    
    if (metaElement) {
      const metaClone = metaElement.cloneNode(true);
      metaClone.style.margin = '0 0 10px 0';
      container.appendChild(metaClone);
    }
    
    document.body.appendChild(container);
    
    try {
      const canvas = await renderBlock(container);
      document.body.removeChild(container);
      return canvas;
    } catch (error) {
      if (container.parentNode) {
        document.body.removeChild(container);
      }
      throw error;
    }
  };
  
  // 添加内容块到PDF的函数，使用直接方式添加内容
  const addContentToPDF = (canvas, offsetY) => {
    try {
      // 确保canvas有有效内容
      if (!canvas || canvas.width <= 0 || canvas.height <= 0) {
        console.warn('无效的canvas，跳过添加');
        return offsetY;
      }
      
      // 使用JPEG格式代替PNG，提高兼容性
      const imgData = canvas.toDataURL('image/jpeg', 0.92);
      
      // 计算图像尺寸，确保比例正确
      const imgWidth = CONTENT_WIDTH;
      // 固定宽度，高度按比例计算
      const imgHeight = canvas.height * (imgWidth / canvas.width);
      
      // 验证计算的尺寸是否有效
      if (isNaN(imgHeight) || imgHeight <= 0 || imgWidth <= 0) {
        console.warn('计算的图像尺寸无效，跳过添加');
        return offsetY;
      }
      
      // 如果内容超出当前页面底部，添加新页面
      if (offsetY + imgHeight > CONTENT_HEIGHT) {
        pdf.addPage();
        offsetY = 0; // 重置Y偏移
      }
      
      // 使用安全的方式添加图像到PDF
      try {
        pdf.addImage({
          imageData: imgData,
          format: 'JPEG',
          x: PAGE_MARGIN_LEFT,
          y: PAGE_MARGIN_TOP + offsetY,
          width: imgWidth,
          height: imgHeight,
          compression: 'FAST'
        });
      } catch (imageError) {
        console.error('添加图像失败，尝试备用方法:', imageError);
        
        // 备用方法: 创建一个文本块代替
        pdf.setFillColor(255, 255, 255);
        pdf.rect(PAGE_MARGIN_LEFT, PAGE_MARGIN_TOP + offsetY, imgWidth, 30, 'F');
        pdf.setTextColor(255, 0, 0);
        pdf.setFontSize(12);
        pdf.text('内容渲染失败', PAGE_MARGIN_LEFT + 10, PAGE_MARGIN_TOP + offsetY + 15);
        
        // 返回一个小的偏移量，继续处理下一块
        return offsetY + 30;
      }
      
      // 更新Y偏移，减少间隙
      return offsetY + imgHeight + 5; // 减少块之间的间隔
    } catch (error) {
      console.error('添加内容到PDF失败:', error);
      // 错误时返回原偏移量加上少量空间，确保进程继续
      return offsetY + 30;
    }
  };
  
  // 处理大图片，确保不会被截断
  const handleLargeImages = () => {
    const images = pdfDom.querySelectorAll('img');
    images.forEach(img => {
      // 检查图片大小，限制过大的图片
      if (img.naturalHeight > CONTENT_HEIGHT * 0.8) {
        const maxHeight = CONTENT_HEIGHT * 0.6; // 降低图片高度上限
        img.style.maxHeight = `${maxHeight}px`;
        img.style.height = 'auto';
        img.style.width = 'auto';
        img.style.maxWidth = '100%';
      }
      
      // 移除图片上下margin
      img.style.margin = '0';
    });
  };
  
  // 创建简单的文本内容
  const createTextContent = (text, y) => {
    pdf.setFillColor(255, 255, 255);
    pdf.rect(PAGE_MARGIN_LEFT, PAGE_MARGIN_TOP + y, CONTENT_WIDTH, 20, 'F');
    pdf.setTextColor(0, 0, 0);
    pdf.setFontSize(10);
    pdf.text(text, PAGE_MARGIN_LEFT + 5, PAGE_MARGIN_TOP + y + 12);
    return y + 20;
  };
  
  // 主执行函数
  const generatePDF = async () => {
    try {
      // 预处理内容
      handleLargeImages();
      
      // 等待所有图片加载完成
      await loadAllImages();
      
      // 初始化PDF文档
      pdf = new window.jspdf.jsPDF({
        orientation: 'portrait',
        unit: 'pt',
        format: 'a4',
        compress: true,
        hotfixes: ['px_scaling', 'px_scaling_legacy']  // 修复可能的缩放问题
      });
      
      // 添加页面标题
      let currentY = 0; // 不添加页面标题，直接从顶部开始
      
      // 尝试渲染标题块
      let titleCanvas = null;
      try {
        titleCanvas = await renderTitleBlock();
        if (titleCanvas) {
          currentY = addContentToPDF(titleCanvas, currentY);
        }
      } catch (error) {
        console.error('渲染标题块失败，将继续处理正文:', error);
        currentY = createTextContent('标题渲染失败', currentY);
      }
      
      // 将内容分解为可单独渲染的块
      const contentBlocks = divideContentIntoBlocks();
      
      // 逐块处理，避免一次创建太多DOM元素
      console.log("开始渲染内容块...");
      
      // 批量处理内容块，每次最多处理15个
      const BATCH_SIZE = 15; // 增大批量处理数量
      for (let i = 0; i < contentBlocks.length; i += BATCH_SIZE) {
        // 获取当前批次的块
        const batch = contentBlocks.slice(i, i + BATCH_SIZE);
        const containers = batch.map((block, index) => createContentBlock(block, i + index));
        
        // 逐个处理当前批次的块
        for (let j = 0; j < containers.length; j++) {
          const container = containers[j];
          const blockIndex = i + j;
          
          try {
            // 渲染内容块
            const canvas = await renderBlock(container);
            
            // 将内容添加到PDF
            currentY = addContentToPDF(canvas, currentY);
            
            // 移除临时容器
            if (container.parentNode) {
              document.body.removeChild(container);
            }
            
            // 打印进度
            if ((blockIndex + 1) % 20 === 0 || blockIndex === contentBlocks.length - 1) {
              console.log(`已渲染 ${blockIndex + 1}/${contentBlocks.length} 个内容块`);
            }
          } catch (error) {
            console.error(`渲染内容块 #${blockIndex} 失败:`, error);
            
            // 移除临时容器
            if (container.parentNode) {
              document.body.removeChild(container);
            }
            
            // 添加错误提示文本
            currentY = createTextContent(`渲染失败: 内容块 #${blockIndex}`, currentY);
          }
        }
        
        // 在批次之间等待一小段时间，减轻浏览器负担
        await new Promise(resolve => setTimeout(resolve, 50)); // 减少等待时间
      }
      
      // 保存PDF
      pdf.save(fileName + '.pdf');
      console.log("PDF生成完成!");
      
      return "PDF生成成功";
    } catch (error) {
      console.error("PDF生成失败:", error);
      throw error;
    } finally {
      // 清理所有临时创建的容器
      const tempContainers = document.querySelectorAll('[data-pdf-block]');
      tempContainers.forEach(container => {
        if (container.parentNode) {
          container.parentNode.removeChild(container);
        }
      });
    }
  };
  
  // 执行PDF生成
  return generatePDF();
}